Use Box<[Type]> inside of FunctionType`
#2036
Merged
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This saves 16 bytes (on 64bit systems) on the stack for each `FunctionType` and additional space on the heap by not allowing resizing (like Vec does)
syrusakbary
approved these changes
Jan 21, 2021
|
bors r+ |
bors bot
added a commit
that referenced
this pull request
Jan 21, 2021
2036: Use Box<[Type]>` inside of `FunctionType` r=syrusakbary a=MarkMcCaskey This saves 16 bytes (on 64bit systems) on the stack for each `FunctionType` and additional space on the heap by not allowing resizing (like Vec does) There are ways to save even more memory here but they're all heavier weight than this simple change. Co-authored-by: Mark McCaskey <[email protected]>
webmaster128
approved these changes
Jan 21, 2021
| params: params.into(), | ||
| results: returns.into(), | ||
| params: params.into().into_boxed_slice(), | ||
| results: returns.into().into_boxed_slice(), |
There was a problem hiding this comment.
Rust can infer the target type of returns.into() to the temporary Vec<Type>? Impressive.
There was a problem hiding this comment.
In this case, params and returns and generic and the only thing we know about these types is that they implement Into<Vec<Type>>, but I agree that it is nice!
| @@ -229,9 +229,9 @@ impl ExternType { | |||
| #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))] | |||
| pub struct FunctionType { | |||
| /// The parameters of the function | |||
| params: Vec<Type>, | |||
| params: Box<[Type]>, | |||
There was a problem hiding this comment.
Does this affect serde somehow?
There was a problem hiding this comment.
I don't believe it should, but that's a good thing to check -- thanks!
There was a problem hiding this comment.
Alright, checked the serde source code: they're both serialized as sequences, so there shouldn't be any effect on the serialization in any format
|
Build failed: |
|
Can wait until we can use Github Actions in our own M1 machines |
|
bors r+ |
bors bot
added a commit
that referenced
this pull request
Jan 21, 2021
2036: Use Box<[Type]>` inside of `FunctionType` r=MarkMcCaskey a=MarkMcCaskey This saves 16 bytes (on 64bit systems) on the stack for each `FunctionType` and additional space on the heap by not allowing resizing (like Vec does) There are ways to save even more memory here but they're all heavier weight than this simple change. Co-authored-by: Mark McCaskey <[email protected]>
|
Build failed: |
|
bors r+ |
bors bot
added a commit
that referenced
this pull request
Jan 21, 2021
2036: Use Box<[Type]>` inside of `FunctionType` r=MarkMcCaskey a=MarkMcCaskey This saves 16 bytes (on 64bit systems) on the stack for each `FunctionType` and additional space on the heap by not allowing resizing (like Vec does) There are ways to save even more memory here but they're all heavier weight than this simple change. Co-authored-by: Mark McCaskey <[email protected]>
|
Build failed: |
|
Merging manually since all tests pass except of the macos-11 due to issues in Github Actions (not in our codebase) |
1 task
bors bot
added a commit
that referenced
this pull request
Feb 26, 2021
2141: feat(types) Avoid allocating a `Vec` when calling `FunctionType::new` r=Hywan a=Hywan # Description Sequel of #2036. We can go further by defining `Params` and `Results` of `FunctionType::new` as `Into<Box<[Type]>>` directly rather than `Into<Vec<Type>>`. It simplifies the code: `params.into()` rather than `params.into().into_boxed_slice()`. I assume it doesn't allocate an intermediate vector. Since `From<Box<[T]>>` is implemented for `Vec<T>`, I reckon it's not a BC break. # Review - [ ] ~Add a short description of the the change to the CHANGELOG.md file~ not necessary Co-authored-by: Ivan Enderlin <[email protected]>
bors bot
added a commit
that referenced
this pull request
Mar 2, 2021
2141: feat(types) Avoid allocating a `Vec` when calling `FunctionType::new` r=syrusakbary a=Hywan # Description Sequel of #2036. We can go further by defining `Params` and `Results` of `FunctionType::new` as `Into<Box<[Type]>>` directly rather than `Into<Vec<Type>>`. It simplifies the code: `params.into()` rather than `params.into().into_boxed_slice()`. I assume it doesn't allocate an intermediate vector. Since `From<Box<[T]>>` is implemented for `Vec<T>`, I reckon it's not a BC break. # Review - [ ] ~Add a short description of the the change to the CHANGELOG.md file~ not necessary Co-authored-by: Ivan Enderlin <[email protected]>
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This saves 16 bytes (on 64bit systems) on the stack for each
FunctionTypeandadditional space on the heap by not allowing resizing (like Vec does)
There are ways to save even more memory here but they're all heavier weight than this simple change.